home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / PIL / ArgImagePlugin.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  10.9 KB  |  370 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __version__ = '0.4'
  5. import marshal
  6. import string
  7. import Image
  8. import ImageFile
  9. import ImagePalette
  10. from PngImagePlugin import i16, i32, ChunkStream, _MODES
  11. MAGIC = '\x8aARG\r\n\x1a\n'
  12.  
  13. class ArgStream(ChunkStream):
  14.     
  15.     def __init__(self, fp):
  16.         ChunkStream.__init__(self, fp)
  17.         self.eof = 0
  18.         self.im = None
  19.         self.palette = None
  20.         self._ArgStream__reset()
  21.  
  22.     
  23.     def __reset(self):
  24.         self.count = 0
  25.         self.id = None
  26.         self.action = ('NONE',)
  27.         self.images = { }
  28.         self.names = { }
  29.  
  30.     
  31.     def chunk_AHDR(self, offset, bytes):
  32.         if self.count != 0:
  33.             raise SyntaxError, 'misplaced AHDR chunk'
  34.         
  35.         s = self.fp.read(bytes)
  36.         self.size = (i32(s), i32(s[4:]))
  37.         
  38.         try:
  39.             (self.mode, self.rawmode) = _MODES[(ord(s[8]), ord(s[9]))]
  40.         except:
  41.             raise SyntaxError, 'unknown ARG mode'
  42.  
  43.         if Image.DEBUG:
  44.             print 'AHDR size', self.size
  45.             print 'AHDR mode', self.mode, self.rawmode
  46.         
  47.         return s
  48.  
  49.     
  50.     def chunk_AFRM(self, offset, bytes):
  51.         if self.count != 0:
  52.             raise SyntaxError, 'misplaced AFRM chunk'
  53.         
  54.         self.show = 1
  55.         self.id = 0
  56.         self.count = 1
  57.         self.repair = None
  58.         s = self.fp.read(bytes)
  59.         if len(s) >= 2:
  60.             self.id = i16(s)
  61.             if len(s) >= 4:
  62.                 self.count = i16(s[2:4])
  63.                 if len(s) >= 6:
  64.                     self.repair = i16(s[4:6])
  65.                 else:
  66.                     self.repair = None
  67.             
  68.         
  69.         if Image.DEBUG:
  70.             print 'AFRM', self.id, self.count
  71.         
  72.         return s
  73.  
  74.     
  75.     def chunk_ADEF(self, offset, bytes):
  76.         if self.count != 0:
  77.             raise SyntaxError, 'misplaced ADEF chunk'
  78.         
  79.         self.show = 0
  80.         self.id = 0
  81.         self.count = 1
  82.         self.repair = None
  83.         s = self.fp.read(bytes)
  84.         if len(s) >= 2:
  85.             self.id = i16(s)
  86.             if len(s) >= 4:
  87.                 self.count = i16(s[2:4])
  88.             
  89.         
  90.         if Image.DEBUG:
  91.             print 'ADEF', self.id, self.count
  92.         
  93.         return s
  94.  
  95.     
  96.     def chunk_NAME(self, offset, bytes):
  97.         if self.count == 0:
  98.             raise SyntaxError, 'misplaced NAME chunk'
  99.         
  100.         name = self.fp.read(bytes)
  101.         self.names[self.id] = name
  102.         return name
  103.  
  104.     
  105.     def chunk_AEND(self, offset, bytes):
  106.         if Image.DEBUG:
  107.             print 'AEND'
  108.         
  109.         self.eof = 1
  110.         raise EOFError, 'end of ARG file'
  111.  
  112.     
  113.     def __getmodesize(self, s, full = 1):
  114.         size = (i32(s), i32(s[4:]))
  115.         
  116.         try:
  117.             (mode, rawmode) = _MODES[(ord(s[8]), ord(s[9]))]
  118.         except:
  119.             raise SyntaxError, 'unknown image mode'
  120.  
  121.         if full:
  122.             if ord(s[12]):
  123.                 pass
  124.             
  125.             if ord(s[11]):
  126.                 raise SyntaxError, 'unknown filter category'
  127.             
  128.         
  129.         return (size, mode, rawmode)
  130.  
  131.     
  132.     def chunk_PAST(self, offset, bytes):
  133.         if self.count == 0:
  134.             raise SyntaxError, 'misplaced PAST chunk'
  135.         
  136.         if self.repair is not None:
  137.             self.images[self.id] = self.images[self.repair].copy()
  138.             self.repair = None
  139.         
  140.         s = self.fp.read(bytes)
  141.         im = self.images[i16(s)]
  142.         x = i32(s[2:6])
  143.         y = i32(s[6:10])
  144.         bbox = (x, y, im.size[0] + x, im.size[1] + y)
  145.         if im.mode in ('RGBA',):
  146.             self.images[self.id].paste(im, bbox, im)
  147.         else:
  148.             self.images[self.id].paste(im, bbox)
  149.         self.action = ('PAST',)
  150.         self._ArgStream__store()
  151.         return s
  152.  
  153.     
  154.     def chunk_BLNK(self, offset, bytes):
  155.         if self.count == 0:
  156.             raise SyntaxError, 'misplaced BLNK chunk'
  157.         
  158.         s = self.fp.read(bytes)
  159.         (size, mode, rawmode) = self._ArgStream__getmodesize(s, 0)
  160.         self.action = ('BLNK',)
  161.         self.im = Image.core.fill(mode, size, 0)
  162.         self._ArgStream__store()
  163.         return s
  164.  
  165.     
  166.     def chunk_IHDR(self, offset, bytes):
  167.         if self.count == 0:
  168.             raise SyntaxError, 'misplaced IHDR chunk'
  169.         
  170.         s = self.fp.read(bytes)
  171.         (size, mode, rawmode) = self._ArgStream__getmodesize(s)
  172.         self.action = ('IHDR',)
  173.         self.im = Image.core.new(mode, size)
  174.         self.decoder = Image.core.zip_decoder(rawmode)
  175.         self.decoder.setimage(self.im, (0, 0) + size)
  176.         self.data = ''
  177.         return s
  178.  
  179.     
  180.     def chunk_DHDR(self, offset, bytes):
  181.         if self.count == 0:
  182.             raise SyntaxError, 'misplaced DHDR chunk'
  183.         
  184.         s = self.fp.read(bytes)
  185.         (size, mode, rawmode) = self._ArgStream__getmodesize(s)
  186.         diff = ord(s[13])
  187.         offs = (i32(s[14:18]), i32(s[18:22]))
  188.         bbox = offs + (offs[0] + size[0], offs[1] + size[1])
  189.         if Image.DEBUG:
  190.             print 'DHDR', diff, bbox
  191.         
  192.         self.action = ('DHDR', diff, bbox)
  193.         self.im = Image.core.new(mode, size)
  194.         self.decoder = Image.core.zip_decoder(rawmode)
  195.         self.decoder.setimage(self.im, (0, 0) + size)
  196.         self.data = ''
  197.         return s
  198.  
  199.     
  200.     def chunk_JHDR(self, offset, bytes):
  201.         if self.count == 0:
  202.             raise SyntaxError, 'misplaced JHDR chunk'
  203.         
  204.         s = self.fp.read(bytes)
  205.         (size, mode, rawmode) = self._ArgStream__getmodesize(s, 0)
  206.         self.action = ('JHDR',)
  207.         self.im = Image.core.new(mode, size)
  208.         self.decoder = Image.core.jpeg_decoder(rawmode)
  209.         self.decoder.setimage(self.im, (0, 0) + size)
  210.         self.data = ''
  211.         return s
  212.  
  213.     
  214.     def chunk_UHDR(self, offset, bytes):
  215.         if self.count == 0:
  216.             raise SyntaxError, 'misplaced UHDR chunk'
  217.         
  218.         s = self.fp.read(bytes)
  219.         (size, mode, rawmode) = self._ArgStream__getmodesize(s, 0)
  220.         self.action = ('UHDR',)
  221.         self.im = Image.core.new(mode, size)
  222.         self.decoder = Image.core.raw_decoder(rawmode)
  223.         self.decoder.setimage(self.im, (0, 0) + size)
  224.         self.data = ''
  225.         return s
  226.  
  227.     
  228.     def chunk_IDAT(self, offset, bytes):
  229.         s = self.fp.read(bytes)
  230.         self.data = self.data + s
  231.         (n, e) = self.decoder.decode(self.data)
  232.         if n < 0:
  233.             if e < 0:
  234.                 raise IOError, 'decoder error %d' % e
  235.             
  236.         else:
  237.             self.data = self.data[n:]
  238.         return s
  239.  
  240.     
  241.     def chunk_DEND(self, offset, bytes):
  242.         return self.chunk_IEND(offset, bytes)
  243.  
  244.     
  245.     def chunk_JEND(self, offset, bytes):
  246.         return self.chunk_IEND(offset, bytes)
  247.  
  248.     
  249.     def chunk_UEND(self, offset, bytes):
  250.         return self.chunk_IEND(offset, bytes)
  251.  
  252.     
  253.     def chunk_IEND(self, offset, bytes):
  254.         del self.decoder
  255.         del self.data
  256.         self._ArgStream__store()
  257.         return self.fp.read(bytes)
  258.  
  259.     
  260.     def __store(self):
  261.         cid = self.action[0]
  262.         if cid in ('BLNK', 'IHDR', 'JHDR', 'UHDR'):
  263.             self.images[self.id] = self.im
  264.         elif cid == 'DHDR':
  265.             (cid, mode, bbox) = self.action
  266.             im0 = self.images[self.id]
  267.             im1 = self.im
  268.             if mode == 0:
  269.                 im1 = im1.chop_add_modulo(im0.crop(bbox))
  270.             
  271.             im0.paste(im1, bbox)
  272.         
  273.         self.count = self.count - 1
  274.         if self.count == 0 and self.show:
  275.             self.im = self.images[self.id]
  276.             raise EOFError
  277.         
  278.  
  279.     
  280.     def chunk_PLTE(self, offset, bytes):
  281.         s = self.fp.read(bytes)
  282.         if self.mode == 'P':
  283.             self.palette = ImagePalette.raw('RGB', s)
  284.         
  285.         return s
  286.  
  287.     
  288.     def chunk_sYNC(self, offset, bytes):
  289.         if self.count != 0:
  290.             raise SyntaxError, 'misplaced sYNC chunk'
  291.         
  292.         s = self.fp.read(bytes)
  293.         self._ArgStream__reset()
  294.         return s
  295.  
  296.  
  297.  
  298. def _accept(prefix):
  299.     return prefix[:8] == MAGIC
  300.  
  301.  
  302. class ArgImageFile(ImageFile.ImageFile):
  303.     format = 'ARG'
  304.     format_description = 'Animated raster graphics'
  305.     
  306.     def _open(self):
  307.         if self.fp.read(8) != MAGIC:
  308.             raise SyntaxError, 'not an ARG file'
  309.         
  310.         self.arg = ArgStream(self.fp)
  311.         (cid, offset, bytes) = self.arg.read()
  312.         if cid != 'AHDR':
  313.             raise SyntaxError, 'expected an AHDR chunk'
  314.         
  315.         s = self.arg.call(cid, offset, bytes)
  316.         self.arg.crc(cid, s)
  317.         self.mode = self.arg.mode
  318.         self.size = self.arg.size
  319.  
  320.     
  321.     def load(self):
  322.         if self.arg.im is None:
  323.             self.seek(0)
  324.         
  325.         self.im = self.arg.im
  326.         self.palette = self.arg.palette
  327.         Image.Image.load(self)
  328.  
  329.     
  330.     def seek(self, frame):
  331.         if self.arg.eof:
  332.             raise EOFError, 'end of animation'
  333.         
  334.         self.fp = self.arg.fp
  335.         while None:
  336.             (cid, offset, bytes) = self.arg.read()
  337.             if self.arg.eof:
  338.                 raise EOFError, 'end of animation'
  339.             
  340.             
  341.             try:
  342.                 s = self.arg.call(cid, offset, bytes)
  343.             except EOFError:
  344.                 break
  345.             except 'glurk':
  346.                 if Image.DEBUG:
  347.                     print cid, bytes, '(unknown)'
  348.                 
  349.                 s = self.fp.read(bytes)
  350.  
  351.             continue
  352.             self.fp.read(4)
  353.             return None
  354.  
  355.     
  356.     def tell(self):
  357.         return 0
  358.  
  359.     
  360.     def verify(self):
  361.         self.fp.seek(8)
  362.         self.arg.verify(self)
  363.         self.arg.close()
  364.         self.fp = None
  365.  
  366.  
  367. Image.register_open('ARG', ArgImageFile, _accept)
  368. Image.register_extension('ARG', '.arg')
  369. Image.register_mime('ARG', 'video/x-arg')
  370.